package cn.sjxy.springaialibaba.controller;

import cn.hutool.core.util.StrUtil;
import jakarta.annotation.Resource;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;

/**
 * 响应实体类，用于统一API返回格式
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
class ApiResponse {
    private boolean success;
    private Object data;
    private String message;
    private long timestamp;
    private String requestId;

    public ApiResponse(boolean success, Object data, String message) {
        this.success = success;
        this.data = data;
        this.message = message;
        this.timestamp = System.currentTimeMillis();
        this.requestId = generateRequestId();
    }

    private String generateRequestId() {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS"));
    }
}

/**
 * AI聊天控制器，提供同步和流式聊天接口
 */
@RestController
@RequestMapping("/api/chat")
@Slf4j
public class ChatHelloController {

    @Resource
    private ChatModel chatModel;

    /**
     * 同步聊天接口 - 提供完整的AI响应
     * @param request 请求体，包含用户消息
     * @return 聊天响应
     */
    @PostMapping("/sync")
    public ResponseEntity<ApiResponse> syncChat(@RequestBody Map<String, String> request) {
        try {
            // 参数提取和验证
            String message = request.getOrDefault("message", "你是谁");
            
            // 输入验证
            if (StrUtil.isBlank(message)) {
                log.warn("接收到空消息的同步聊天请求");
                return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                        .body(new ApiResponse(false, null, "消息内容不能为空"));
            }
            
            // 限制消息长度，防止过长请求
            if (message.length() > 2000) {
                log.warn("接收到过长消息的同步聊天请求，长度: {}", message.length());
                return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                        .body(new ApiResponse(false, null, "消息长度不能超过2000个字符"));
            }
            
            log.info("接收同步聊天请求: {}", message.substring(0, Math.min(100, message.length())));
            long startTime = System.currentTimeMillis();
            
            // 调用AI模型
            String result = chatModel.call(message);
            
            long responseTime = System.currentTimeMillis() - startTime;
            log.info("同步聊天响应耗时: {}ms, 响应长度: {}", responseTime, result.length());
            
            // 性能监控 - 记录慢请求
            if (responseTime > 5000) {
                log.warn("同步聊天请求处理较慢: {}ms", responseTime);
            }
            
            return ResponseEntity.ok(new ApiResponse(true, result, "请求成功"));
        } catch (Exception e) {
            log.error("同步聊天请求异常: {}", e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(new ApiResponse(false, null, "服务器处理异常: " + e.getMessage()));
        }
    }

    /**
     * 流式聊天接口 - 逐字返回AI响应
     * @param request 请求体，包含用户消息
     * @return 流式响应
     */
    @PostMapping("/stream")
    public Flux<String> streamChat(@RequestBody Map<String, String> request) {
        try {
            // 参数提取和验证
            String message = request.getOrDefault("message", "你是谁");
            
            // 输入验证
            if (StrUtil.isBlank(message)) {
                log.warn("接收到空消息的流式聊天请求");
                return Flux.just("错误: 消息内容不能为空");
            }
            
            // 限制消息长度
            if (message.length() > 2000) {
                log.warn("接收到过长消息的流式聊天请求，长度: {}", message.length());
                return Flux.just("错误: 消息长度不能超过2000个字符");
            }
            
            log.info("接收流式聊天请求: {}", message.substring(0, Math.min(100, message.length())));
            
            // 返回流式响应
            return chatModel.stream(message)
                    .doOnError(error -> log.error("流式响应处理异常: {}", error.getMessage(), error))
                    .doFinally(signal -> log.info("流式聊天请求处理完成"));
        } catch (Exception e) {
            log.error("流式聊天请求异常: {}", e.getMessage(), e);
            return Flux.just("错误: 服务器处理异常: " + e.getMessage());
        }
    }

    /**
     * 旧版流式接口 - 仅用于兼容旧系统，建议使用 /api/chat/stream 接口
     * @param msg 用户消息
     * @return 流式响应
     * @deprecated 建议使用 POST /api/chat/stream 接口
     */
    @Deprecated
    @GetMapping("/hello/streamchat")
    public Flux<String> streamChatLegacy(@RequestParam(name = "msg", defaultValue = "你是谁") String msg) {
        log.warn("检测到使用旧版流式接口，请迁移至 POST /api/chat/stream");
        return chatModel.stream(msg);
    }
}
